Mašininio mokymosi konvejeris: Individualių „Scikit-learn“ transformatorių kūrimas

Mašininio mokymosi konvejeriai yra būtini kuriant patikimus ir lengvai prižiūrimus mašininio mokymosi modelius. „Scikit-learn“ (sklearn) suteikia galingą sistemą šiems konvejeriams kurti. Svarbus bet kurio gero konvejerio komponentas yra galimybė atlikti individualias duomenų transformacijas. Šiame straipsnyje nagrinėjamas individualių transformatorių kūrimas „scikit-learn“ bibliotekoje, pateikiant išsamų vadovą duomenų mokslininkams ir mašininio mokymosi inžinieriams visame pasaulyje.

Kas yra mašininio mokymosi konvejeris?

Mašininio mokymosi konvejeris – tai nuosekli duomenų apdorojimo komponentų grandinė. Šie komponentai paprastai apima:

• Duomenų valymas: Trūkstamų verčių, išskirčių ir neatitikimų tvarkymas.
• Požymių inžinerija: Naujų požymių kūrimas iš esamų, siekiant pagerinti modelio veikimą.
• Požymių atrinkimas: Svarbiausių požymių atrinkimas modeliui.
• Modelio apmokymas: Mašininio mokymosi modelio apmokymas su paruoštais duomenimis.
• Modelio vertinimas: Apmokyto modelio veikimo įvertinimas.

Konvejerio naudojimas suteikia keletą privalumų, įskaitant:

• Atkuriamumas: Užtikrinimas, kad tie patys duomenų apdorojimo žingsniai būtų taikomi nuosekliai.
• Moduliškumas: Duomenų apdorojimo eigos suskaidymas į pakartotinai naudojamus komponentus.
• Priežiūros paprastumas: Lengvesnis duomenų apdorojimo eigos atnaujinimas ir priežiūra.
• Supaprastintas diegimas: Mašininio mokymosi modelių diegimo proceso supaprastinimas.

Kodėl reikalingi individualūs transformatoriai?

„Scikit-learn“ siūlo platų integruotų transformatorių asortimentą įprastoms duomenų apdorojimo užduotims. Tačiau daugelyje realių scenarijų jums reikės atlikti individualias duomenų transformacijas, būdingas jūsų duomenims ir problemai. Būtent čia praverčia individualūs transformatoriai. Jie leidžia apgaubti jūsų individualią duomenų apdorojimo logiką į pakartotinai naudojamus komponentus, kuriuos galima sklandžiai integruoti į „scikit-learn“ konvejerį.

Pavyzdžiui, įsivaizduokite, kad dirbate su klientų duomenimis iš pasaulinės el. prekybos platformos. Jums gali prireikti sukurti individualų transformatorių, kuris konvertuotų transakcijų valiutas į bendrą valiutą (pvz., USD), remiantis istoriniais valiutų kursais. Arba apsvarstykite scenarijų, susijusį su jutiklių duomenimis iš daiktų interneto (IoT) įrenginių įvairiose šalyse; galėtumėte sukurti individualų transformatorių, kuris normalizuotų duomenis pagal vietines laiko juostas ir matavimo vienetus.

Individualaus transformatoriaus kūrimas

Norėdami sukurti individualų transformatorių „scikit-learn“, turite sukurti klasę, kuri paveldi iš sklearn.base.BaseEstimator ir sklearn.base.TransformerMixin. Jūsų klasė turi įgyvendinti du metodus:

• fit(self, X, y=None): Šis metodas išmoksta visus transformacijai reikalingus parametrus. Daugeliu atvejų šis metodas tiesiog grąžina self.
• transform(self, X): Šis metodas pritaiko transformaciją duomenims.

Štai pagrindinis individualaus transformatoriaus pavyzdys, kuris prie kiekvieno požymio prideda pastovią reikšmę:

            from sklearn.base import BaseEstimator, TransformerMixin
import numpy as np

class AddConstantTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, constant=1):
        self.constant = constant

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        return X + self.constant

            

              
                Copy
              
            
          

Išnagrinėkime šį pavyzdį:

• Būtinų bibliotekų importavimas: BaseEstimator, TransformerMixin iš sklearn.base ir numpy skaitinėms operacijoms.
• Klasės apibrėžimas: AddConstantTransformer paveldi iš BaseEstimator ir TransformerMixin.
• Konstruktorius (__init__): Šis metodas inicializuoja transformatorių su constant reikšme (pagal nutylėjimą lygi 1).
• fit metodas: Šis metodas tiesiog grąžina self, nes šiam transformatoriui nereikia išmokti jokių parametrų iš duomenų.
• transform metodas: Šis metodas prideda constant reikšmę prie kiekvieno elemento įvesties duomenyse X.

Naudojimo pavyzdys

            from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

X = np.array([[1, 2], [3, 4], [5, 6]])

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('add_constant', AddConstantTransformer(constant=2))
])

X_transformed = pipeline.fit_transform(X)

print(X_transformed)

            

              
                Copy
              
            
          

Šis pavyzdys parodo, kaip naudoti AddConstantTransformer konvejeryje. Pirmiausia duomenys yra standartizuojami naudojant StandardScaler, o tada pridedama konstanta naudojant mūsų individualų transformatorių.

Pažangus individualių transformatorių kūrimas

Dabar panagrinėkime keletą sudėtingesnių scenarijų ir technikų, skirtų individualiems transformatoriams kurti.

Kategorinių požymių tvarkymas

Kategoriniai požymiai yra įprastas duomenų tipas mašininiame mokymesi. Galite sukurti individualius transformatorius, skirtus atlikti įvairias operacijas su kategoriniais požymiais, tokias kaip „one-hot“ kodavimas, žymių kodavimas (label encoding) ar požymių maišymas (feature hashing).

Štai individualaus transformatoriaus pavyzdys, kuris atlieka „one-hot“ kodavimą nurodytiems stulpeliams:

            import pandas as pd
from sklearn.preprocessing import OneHotEncoder

class CategoricalEncoder(BaseEstimator, TransformerMixin):
    def __init__(self, categorical_features=None):
        self.categorical_features = categorical_features
        self.encoder = None

    def fit(self, X, y=None):
        if self.categorical_features is None:
            self.categorical_features = X.select_dtypes(include=['object']).columns

        self.encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
        self.encoder.fit(X[self.categorical_features])
        return self

    def transform(self, X):
        X_encoded = self.encoder.transform(X[self.categorical_features])
        X_encoded = pd.DataFrame(X_encoded, index=X.index, columns=self.encoder.get_feature_names_out(self.categorical_features))
        X = X.drop(columns=self.categorical_features)
        X = pd.concat([X, X_encoded], axis=1)
        return X

            

              
                Copy
              
            
          

Šiame pavyzdyje:

• Transformatorius automatiškai identifikuoja kategorinius stulpelius (jei jie nenurodyti).
• Jis naudoja OneHotEncoder iš „scikit-learn“ kodavimui atlikti.
• Jis tvarko nežinomas kategorijas naudodamas handle_unknown='ignore'.
• Užkoduoti požymiai yra sujungiami atgal su pradiniu duomenų rėmeliu (dataframe).

Trūkstamų verčių tvarkymas

Trūkstamos vertės yra dar viena dažna problema mašininio mokymosi duomenų rinkiniuose. Galite sukurti individualius transformatorius, skirtus trūkstamoms vertėms užpildyti naudojant įvairias strategijas, tokias kaip vidurkio, medianos ar modos imputacija.

Štai individualaus transformatoriaus pavyzdys, kuris užpildo trūkstamas vertes naudojant medianą:

            from sklearn.impute import SimpleImputer

class MissingValueImputer(BaseEstimator, TransformerMixin):
    def __init__(self, strategy='median', missing_values=np.nan):
        self.strategy = strategy
        self.missing_values = missing_values
        self.imputer = None

    def fit(self, X, y=None):
        self.imputer = SimpleImputer(strategy=self.strategy, missing_values=self.missing_values)
        self.imputer.fit(X)
        return self

    def transform(self, X):
        return self.imputer.transform(X)

            

              
                Copy
              
            
          

Šis transformatorius naudoja SimpleImputer iš „scikit-learn“ imputacijai atlikti. Jis leidžia nurodyti imputacijos strategiją ir reikšmę, naudojamą trūkstamoms vertėms žymėti.

Požymių mastelio keitimas ir normalizavimas

Požymių mastelio keitimas ir normalizavimas yra svarbūs parengiamojo apdorojimo žingsniai daugeliui mašininio mokymosi algoritmų. Galite sukurti individualius transformatorius, skirtus įgyvendinti skirtingas mastelio keitimo ir normalizavimo technikas.

Nors „scikit-learn“ siūlo tokius transformatorius kaip StandardScaler ir MinMaxScaler, jums gali prireikti individualaus keitiklio specifiniams duomenų pasiskirstymams. Pavyzdžiui, jei turite duomenis su labai asimetrišku pasiskirstymu, PowerTransformer (taip pat prieinamas „scikit-learn“) gali būti tinkamesnis. Tačiau galite jį apgaubti individualiame transformatoriuje, kad valdytumėte jo parametrus ir sklandžiai integruotumėte į savo konvejerį.

            from sklearn.preprocessing import PowerTransformer

class SkewedDataTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, method='yeo-johnson'):
        self.method = method
        self.transformer = None

    def fit(self, X, y=None):
        self.transformer = PowerTransformer(method=self.method)
        self.transformer.fit(X)
        return self

    def transform(self, X):
        return self.transformer.transform(X)

            

              
                Copy
              
            
          

Kelių transformacijų derinimas

Kartais gali prireikti pritaikyti kelias transformacijas tiems pačiams duomenims. Galite sukurti individualų transformatorių, kuris sujungia kelias transformacijas į vieną žingsnį. Tai gali padėti supaprastinti jūsų konvejerį ir padaryti jį skaitomesnį.

Štai individualaus transformatoriaus pavyzdys, kuris sujungia „one-hot“ kodavimą ir trūkstamų verčių imputaciją:

            class CombinedTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, categorical_features=None, missing_value_strategy='median'):
        self.categorical_features = categorical_features
        self.missing_value_strategy = missing_value_strategy
        self.categorical_encoder = None
        self.missing_value_imputer = None

    def fit(self, X, y=None):
        self.categorical_encoder = CategoricalEncoder(categorical_features=self.categorical_features)
        self.missing_value_imputer = MissingValueImputer(strategy=self.missing_value_strategy)
        self.categorical_encoder.fit(X)
        self.missing_value_imputer.fit(X)
        return self

    def transform(self, X):
        X = self.categorical_encoder.transform(X)
        X = self.missing_value_imputer.transform(X)
        return X

            

              
                Copy
              
            
          

Šis transformatorius naudoja CategoricalEncoder ir MissingValueImputer iš ankstesnių pavyzdžių, kad atliktų tiek „one-hot“ kodavimą, tiek trūkstamų verčių imputaciją vienu žingsniu.

Geroji individualių transformatorių kūrimo praktika

Štai keletas gerosios praktikos pavyzdžių, kurių reikėtų laikytis kuriant individualius transformatorius:

• Paprastumas: Kiekvienas transformatorius turėtų atlikti vieną, aiškiai apibrėžtą užduotį.
• Pakartotinis naudojimas: Kurkite transformatorius kuo universalesnius, kad juos būtų galima pakartotinai naudoti skirtinguose konvejeriuose.
• Išskirtinių atvejų tvarkymas: Apsvarstykite, kaip jūsų transformatorius tvarkys išskirtinius atvejus, tokius kaip trūkstamos vertės, išskirtys ir netikėti duomenų tipai.
• Rašykite vienetinius testus (unit tests): Rašykite vienetinius testus, kad užtikrintumėte, jog jūsų transformatorius veikia teisingai.
• Dokumentuokite savo kodą: Aiškiai dokumentuokite savo kodą, kad kiti galėtų suprasti, kaip naudoti jūsų transformatorių.

Realaus pasaulio pavyzdžiai

Panagrinėkime keletą realaus pasaulio individualių transformatorių pavyzdžių.

Datos požymių inžinerija

Dirbant su laiko eilučių duomenimis, dažnai naudinga iš datų išgauti požymius, tokius kaip savaitės diena, metų mėnuo ar metų ketvirtis. Galite sukurti individualų transformatorių šiai užduočiai atlikti.

            class DateFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, date_columns=None):
        self.date_columns = date_columns

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        for col in self.date_columns:
            X[col + '_dayofweek'] = X[col].dt.dayofweek
            X[col + '_month'] = X[col].dt.month
            X[col + '_quarter'] = X[col].dt.quarter
        return X

            

              
                Copy
              
            
          

Šis transformatorius iš nurodytų datos stulpelių išgauna savaitės dieną, mėnesį ir ketvirtį.

Teksto požymių inžinerija

Dirbant su tekstiniais duomenimis, dažnai naudinga atlikti požymių inžineriją naudojant tokias technikas kaip TF-IDF ar žodžių įterpimas (word embeddings). Galite sukurti individualius transformatorius šioms užduotims atlikti. Pavyzdžiui, apsvarstykite klientų atsiliepimus keliomis kalbomis. Jums gali prireikti individualaus transformatoriaus, kuris išverstų atsiliepimus į anglų kalbą prieš taikant TF-IDF vektorizavimą.

Pastaba: Vertimo paslaugoms dažnai reikalingi API raktai ir jos gali būti mokamos. Šis pavyzdys sutelktas į individualaus transformatoriaus struktūrą.

            # Note: This example requires a translation service (e.g., Google Translate API) and API key
# from googletrans import Translator # Example library (install with pip install googletrans==4.0.0-rc1)

class TextFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, text_column, language='en'):
        self.text_column = text_column
        self.language = language
        # self.translator = Translator() # Instantiate translator (requires setup)

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        # Example: Translate to English (replace with actual translation logic)
        # X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: self.translator.translate(text, dest=self.language).text)
        # Dummy translation for demonstration purposes
        X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: "Translated: " + text)

        # Apply TF-IDF or other text vectorization techniques here
        return X

            

              
                Copy
              
            
          

Geopriestranių požymių inžinerija

Dirbant su geopriestranniais duomenimis, galite sukurti individualius transformatorius, skirtus išgauti tokius požymius kaip atstumas iki artimiausio miesto, gyventojų tankumas ar žemės naudojimo tipas. Pavyzdžiui, apsvarstykite nekilnojamojo turto kainų analizę visame pasaulyje. Galėtumėte sukurti individualų transformatorių, kuris, remdamasis platuma ir ilguma, gautų vidutinį pajamų lygį tam tikroje vietoje, naudodamas išorines API.

Integracija su esamomis bibliotekomis

Individualūs transformatoriai gali būti naudojami apgaubti funkcionalumą iš kitų Python bibliotekų į „scikit-learn“ konvejerį. Tai leidžia jums pasinaudoti kitų bibliotekų galia, tuo pačiu metu mėgaujantis konvejerio struktūra ir organizuotumu.

Pavyzdžiui, galite naudoti individualų transformatorių, kad integruotumėte anomalijų aptikimo, laiko eilučių prognozavimo ar vaizdų apdorojimo biblioteką į savo mašininio mokymosi konvejerį.

Išvada

Individualūs transformatoriai yra galingas įrankis kuriant patikimus ir lengvai prižiūrimus mašininio mokymosi konvejerius „scikit-learn“ bibliotekoje. Apgaubdami savo individualią duomenų apdorojimo logiką į pakartotinai naudojamus komponentus, galite sukurti konvejerius, kuriuos lengviau suprasti, atnaujinti ir diegti. Nepamirškite laikytis gerosios praktikos, rašyti vienetinius testus ir dokumentuoti savo kodą, kad užtikrintumėte, jog jūsų individualūs transformatoriai yra patikimi ir lengvai prižiūrimi. Tobulėjant jūsų mašininio mokymosi įgūdžiams, individualių transformatorių kūrimo įvaldymas taps neįkainojamas sprendžiant sudėtingas ir įvairias realaus pasaulio problemas visame pasaulyje. Nuo valiutų konvertavimo tarptautinėje el. prekyboje iki jutiklių duomenų apdorojimo iš daiktų interneto įrenginių visame pasaulyje – individualūs transformatoriai suteikia jums galimybę pritaikyti savo konvejerius specifiniams jūsų duomenų ir programų poreikiams.